package com.wicket.okrcomponent.biz.service.nb;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrcomponent.biz.service.TemplateEngineService;
import com.wicket.okrcomponent.biz.service.dto.common.FieldsNameAndValueToOneDatasDto;
import com.wicket.okrcomponent.biz.service.dto.req.*;
import com.wicket.okrcomponent.biz.service.dto.res.*;
import com.wicket.okrcomponent.common.annotations.BanAuto;
import com.wicket.okrcomponent.common.util.CommonFunctionHelper;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Random;

/**
 * @author ： 手工接入方法
 * @since 2022/5/28 15:32
 *
 *
 * @version 1.0
 */
@Service
@BanAuto
public class NbTemplateEngine {

    @Autowired
    TemplateEngineService templateEngineService;
    /**
     * code:generateSemanticInstance
     * name:生成语义实例
     * desc:undefined
     **/
    @BanAuto
    @Trace(operationName = "生成语义实例")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateSemanticInstanceResDto generateSemanticInstance(GenerateSemanticInstanceReqDto reqDto) {
        GenerateSemanticInstanceResDto retData = new GenerateSemanticInstanceResDto();
        SimpleDateFormat ft = new SimpleDateFormat("yyyyMMddHH:mm:ss");
        String timeStr = ft.format(CommonFunctionHelper.getCurrentTime());
        retData.setTemplateContent(reqDto.getSentenceContentParam() + timeStr);
        return retData;
    }
/**
      * code:receptionService
      * name:M2-获取接收字段
      * desc:undefined
      * gen by moon at 10/27/2022, 6:28:21 PM
      *
      **/
     @Trace(operationName = "M2-获取接收字段")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ObtainReceiveFieldsRespDto obtainReceiveFields(ObtainReceiveFieldsReqDto reqDto) {
        return BeanUtil.toBean(reqDto,ObtainReceiveFieldsRespDto.class);
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（目标周期名称）
      * desc:undefined
      * gen by moon at 10/27/2022, 6:28:27 PM
      *
      **/
     @Trace(operationName = "M2生成语义内容服务（目标周期名称）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public GenerateTargetCycleNameRespDto generateTargetCycleName(GenerateTargetCycleNameReqDto reqDto) {
         //{cycleStandardName}{targetContentName}
         Boolean bRetFlag = false;
         String retConent = "";
         GenerateTargetCycleNameRespDto retData = new GenerateTargetCycleNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("GENERATE_TARGET_CYCLE_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getCycleStandardName()!=null && reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName, reqDto.getTargetContentName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,"---");
                 retConent = retConent.replaceAll(targetContentName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（周期名称）
      * desc:undefined
      * gen by moon at 10/27/2022, 6:28:33 PM
      *
      **/
     @Trace(operationName = "M2生成语义内容服务（周期名称）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public GenerateTotalCycleNameRespDto generateTotalCycleName(GenerateTotalCycleNameReqDto reqDto) {
         //{cycleStartName}-{cycleEndName}
         Boolean bRetFlag = false;
         String retConent = "";
         GenerateTotalCycleNameRespDto retData = new GenerateTotalCycleNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("GENERATE_TOTAL_CYCLE_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStartName = "\\{cycleStartName}";
             String cycleEndName = "\\{cycleEndName}";
             if(reqDto.getCycleStartName()!=null && reqDto.getCycleEndName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStartName,reqDto.getCycleStartName());
                 retConent = retConent.replaceAll(cycleEndName, reqDto.getCycleEndName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStartName,"---");
                 retConent = retConent.replaceAll(cycleEndName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（不规则周期名称）
      * desc:undefined
      * gen by moon at 10/27/2022, 6:28:39 PM
      *
      **/
     @Trace(operationName = "M2生成语义内容服务（不规则周期名称）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public GenerateIrregularCycleNameRespDto generateIrregularCycleName(GenerateIrregularCycleNameReqDto reqDto) {
         //{cycleStartTime} 至 {cycleEndTime}
         Boolean bRetFlag = false;
         String retConent = "";
         GenerateIrregularCycleNameRespDto retData = new GenerateIrregularCycleNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("GENERATE_IRREGULAR_CYCLE_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStartTime = "\\{cycleStartTime}";
             String cycleEndTime = "\\{cycleEndTime}";
             if(reqDto.getCycleStartTime()!=null && reqDto.getCycleEndTime()!=null){
                 bRetFlag = true;
                 String start = CommonFunctionHelper.date2specStr(reqDto.getCycleStartTime());
                 start = start.substring(2,start.length());

                 String end = CommonFunctionHelper.date2specStr(reqDto.getCycleEndTime());
                 end = end.substring(2,end.length());
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStartTime,start);
                 retConent = retConent.replaceAll(cycleEndTime, end);
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStartTime,"---");
                 retConent = retConent.replaceAll(cycleEndTime,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（不规则周期类型名称）
      * desc:undefined
      * gen by moon at 10/27/2022, 6:28:45 PM
      *
      **/
     @Trace(operationName = "M2生成语义内容服务（不规则周期类型名称）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateIrregularCycleTypeNameRespDto createIrregularCycleTypeName(CreateIrregularCycleTypeNameReqDto reqDto) {
         //{acount}个{cycleTypeName}
         Boolean bRetFlag = false;
         String retConent = "";
         CreateIrregularCycleTypeNameRespDto retData = new CreateIrregularCycleTypeNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_IRREGULAR_CYCLE_TYPE_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String acount = "\\{acount}";
             String cycleTypeName = "\\{cycleTypeName}";
             if(reqDto.getAcount()!=null && reqDto.getCycleTypeName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(acount,String.valueOf(reqDto.getAcount()));
                 retConent = retConent.replaceAll(cycleTypeName, reqDto.getCycleTypeName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(acount,"---");
                 retConent = retConent.replaceAll(cycleTypeName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（不规则周期类型标识）
      * desc:undefined
      * gen by moon at 10/27/2022, 6:28:51 PM
      *
      **/
     @Trace(operationName = "M2生成语义内容服务（不规则周期类型标识）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateCycleTypeCodeRespDto createCycleTypeCode(CreateCycleTypeCodeReqDto reqDto) {
         //{acount}{cycleTypeCode}
         Boolean bRetFlag = false;
         String retConent = "";
         CreateCycleTypeCodeRespDto retData = new CreateCycleTypeCodeRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_CYCLE_TYPE_CODE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String acount = "\\{acount}";
             String cycleTypeCode = "\\{cycleTypeCode}";
             if(reqDto.getAcount()!=null && reqDto.getCycleTypeCode()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(acount,String.valueOf(reqDto.getAcount()));
                 retConent = retConent.replaceAll(cycleTypeCode, reqDto.getCycleTypeCode());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(acount,"---");
                 retConent = retConent.replaceAll(cycleTypeCode,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（分工内容名称生成分工策略描述）
      * desc:undefined
      * gen by moon at 11/1/2022, 9:48:31 PM
      * 
      **/
     @Trace(operationName = "M2生成语义内容服务（分工内容名称生成分工策略描述）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public DivisionContNameCreateDivisionDescRespDto divisionContNameCreateDivisionDesc(DivisionContNameCreateDivisionDescReqDto reqDto) {
         //当前目标由{divisionContName}牵头直接汇报即可
         Boolean bRetFlag = false;
         String retConent = "";
         DivisionContNameCreateDivisionDescRespDto retData = new DivisionContNameCreateDivisionDescRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("DIVISION_CONT_NAME_CREATE_DIVISION_DESC");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String divisionContName = "\\{divisionContName}";
             if(reqDto.getDivisionContName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(divisionContName,reqDto.getDivisionContName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(divisionContName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（编码名称生成分工策略描述）
      * desc:undefined
      * gen by moon at 11/1/2022, 9:48:37 PM
      * 
      **/
     @Trace(operationName = "M2生成语义内容服务（编码名称生成分工策略描述）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CodeNameCreateDivisionDescRespDto codeNameCreateDivisionDesc(CodeNameCreateDivisionDescReqDto reqDto) {
         //当前目标{codeName}
         Boolean bRetFlag = false;
         String retConent = "";
         CodeNameCreateDivisionDescRespDto retData = new CodeNameCreateDivisionDescRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CODE_NAME_CREATE_DIVISION_DESC");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String codeName = "\\{codeName}";
             if(reqDto.getCodeName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(codeName,reqDto.getCodeName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(codeName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（评价模板批次名称模板）
      * desc:undefined
      * gen by moon at 11/1/2022, 9:48:43 PM
      * 
      **/
     @Trace(operationName = "M2生成语义内容服务（评价模板批次名称模板）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public GenerateEvaTempBatchNameRespDto generateEvaTempBatchName(GenerateEvaTempBatchNameReqDto reqDto) {
         //{systemDateTime}{randomNumberDigits}{targetContentName}批次
         Boolean bRetFlag = false;
         String retConent = "";
         GenerateEvaTempBatchNameRespDto retData = new GenerateEvaTempBatchNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("GENERATE_EVA_TEMP_BATCH_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String systemDateTime = "\\{systemDateTime}";
             String randomNumberDigits = "\\{randomNumberDigits}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null && !reqDto.getTargetContentName().isEmpty()){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(systemDateTime,CommonFunctionHelper.date2Str(CommonFunctionHelper.getCurrentTime()));
                 Random random = new Random();
                 String result="";
                 for (int i=0;i<reqDto.getRandomNumberDigits();i++)
                 {
                     result+=random.nextInt(10);
                 }
                 retConent = retConent.replaceAll(randomNumberDigits,result);
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（组织架构批次名称）
      * desc:undefined
      * gen by moon at 11/1/2022, 9:48:48 PM
      * 
      **/
     @Trace(operationName = "M2生成语义内容服务（组织架构批次名称）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateOrgBatchNameRespDto createOrgBatchName(CreateOrgBatchNameReqDto reqDto) {
         //{systemDateTime}{sixRandomNum}{spaceName}组织编制批次
         Boolean bRetFlag = false;
         String retConent = "";
         CreateOrgBatchNameRespDto retData = new CreateOrgBatchNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_ORG_BATCH_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String systemDateTime = "\\{systemDateTime}";
             String sixRandomNum = "\\{sixRandomNum}";
             String spaceName = "\\{spaceName}";
             if(reqDto.getSpaceName()!=null && !reqDto.getSpaceName().isEmpty()){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(spaceName,reqDto.getSpaceName());
                 retConent = retConent.replaceAll(systemDateTime,CommonFunctionHelper.date2Str(CommonFunctionHelper.getCurrentTime()));
                 Random random = new Random();
                 String result="";
                 for (int i=0;i<reqDto.getRandomNumberDigits();i++)
                 {
                     result+=random.nextInt(10);
                 }
                 retConent = retConent.replaceAll(sixRandomNum,result);
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(spaceName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义内容服务（部门目标任务书树当前叶子调度任务名称）
      * desc:undefined
      * gen by moon at 11/3/2022, 9:54:03 PM
      * 
      **/
     @Trace(operationName = "M2生成语义内容服务（部门目标任务书树当前叶子调度任务名称）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateDeptTargetTreeLeafTaskNameRespDto createDeptTargetTreeLeafTaskName(CreateDeptTargetTreeLeafTaskNameReqDto reqDto) {
        //{objectiveShortName}：部门目标任务书树当前叶子调度任务
         Boolean bRetFlag = false;
         String retConent = "";
         CreateDeptTargetTreeLeafTaskNameRespDto retData = new CreateDeptTargetTreeLeafTaskNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_DEPT_TARGET_TREE_LEAF_TASK_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String objectiveShortName = "\\{objectiveShortName}";
             if(reqDto.getObjectiveShortName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectiveShortName,reqDto.getObjectiveShortName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectiveShortName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成校验目标周期不合理故事提示
      * desc:undefined
      * gen by moon at 11/20/2022, 12:10:11 AM
      * 
      **/
     @Trace(operationName = "M2生成校验目标周期不合理故事提示")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public GenerateSemanticContentServiceRespDto generateSemanticContentService(GenerateSemanticContentServiceReqDto reqDto) {
         //{cyclelAlias}下没有制定目标
         Boolean bRetFlag = false;
         String retConent = "";
         GenerateSemanticContentServiceRespDto retData = new GenerateSemanticContentServiceRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("TARGET_CYCLE_CHECK_IRRATIONAL_STORY_TIPS");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cyclelAlias = "\\{cyclelAlias}";
             if(reqDto.getCyclelAlias()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias,reqDto.getCyclelAlias());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成参与者新增异常提示故事
      * desc:undefined
      * gen by moon at 12/5/2022, 1:57:08 PM
      * 
      **/
     @Trace(operationName = "M2生成参与者新增异常提示故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateParticipatorAbnormalStoryTipsRespDto createParticipatorAbnormalStoryTips(CreateParticipatorAbnormalStoryTipsReqDto reqDto) {
         //{idCardName}已是{virtualOrganizationPosition}，不能再设为参与者。
         Boolean bRetFlag = false;
         String retConent = "";
         CreateParticipatorAbnormalStoryTipsRespDto retData = new CreateParticipatorAbnormalStoryTipsRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_PARTICIPATOR_ABNORMAL_STORY_TIPS");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String virtualOrganizationPosition = "\\{virtualOrganizationPosition}";
             if(reqDto.getIdCardName()!=null && reqDto.getVirtualOrganizationPosition()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retConent = retConent.replaceAll(virtualOrganizationPosition,reqDto.getVirtualOrganizationPosition());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,"---");
                 retConent = retConent.replaceAll(virtualOrganizationPosition,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成变更字段语义故事内容
      * desc:undefined
      * gen by moon at 12/5/2022, 1:57:13 PM
      * 
      **/
     @Trace(operationName = "M2-生成变更字段语义故事内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public SubjectChangeContRespDto subjectChangeCont(SubjectChangeContReqDto reqDto) {
         //{reviseSubjectContent}{reviseBehaviorName}：{columnContent}
         Boolean bRetFlag = false;
         String retConent = "";
         SubjectChangeContRespDto retData = new SubjectChangeContRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("SUBJECT_CHANGE_CONT");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String reviseSubjectContent = "\\{reviseSubjectContent}";
             String reviseBehaviorName = "\\{reviseBehaviorName}";
             String columnContent = "\\{columnContent}";
             if(reqDto.getReviseSubjectContent()!=null && reqDto.getReviseBehaviorName()!=null&& reqDto.getColumnContent()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent,reqDto.getReviseSubjectContent());
                 retConent = retConent.replaceAll(reviseBehaviorName,reqDto.getReviseBehaviorName());
                 retConent = retConent.replaceAll(columnContent,reqDto.getColumnContent());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent,"---");
                 retConent = retConent.replaceAll(reviseBehaviorName,"---");
                 retConent = retConent.replaceAll(columnContent,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成目标内容祖先目标父子状态调度任务名称
      * desc:undefined
      * gen by moon at 1/10/2023, 4:35:47 PM
      *
      **/
     @Trace(operationName = "M2生成目标内容祖先目标父子状态调度任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateTargetContAnceParentStaTaskRespDto createTargetContAnceParentStaTask(CreateTargetContAnceParentStaTaskReqDto reqDto) {
        //{targetContentName}：目标内容祖先目标父子状态调度任务
         Boolean bRetFlag = false;
         String retConent = "";
         CreateTargetContAnceParentStaTaskRespDto retData = new CreateTargetContAnceParentStaTaskRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_TARGET_CONT_ANCE_PARENT_STA_TASK_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null && reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成评价模板调度汇报任务名称
      * desc:undefined
      * gen by moon at 1/10/2023, 4:35:52 PM
      *
      **/
     @Trace(operationName = "M2生成评价模板调度汇报任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateTempCycleStageDispatchNameRespDto createTempCycleStageDispatchName(CreateTempCycleStageDispatchNameReqDto reqDto) {
         //{cyclelAlias}：生成评价模板调度汇报任务
         Boolean bRetFlag = false;
         String retConent = "";
         CreateTempCycleStageDispatchNameRespDto retData = new CreateTempCycleStageDispatchNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_TEMP_CYCLE_STAGE_DISPATCH_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cyclelAlias = "\\{cyclelAlias}";
             if(reqDto.getCyclelAlias()!=null && reqDto.getCyclelAlias()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias,reqDto.getCyclelAlias());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name: M2生成OKR个人树调度任务名称
      * desc:undefined
      * gen by moon at 1/10/2023, 4:35:58 PM
      *
      **/
     @Trace(operationName = " M2生成OKR个人树调度任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateOkrPersonalTreeDataNameRespDto createOkrPersonalTreeDataName(CreateOkrPersonalTreeDataNameReqDto reqDto) {
         //生成{targetContentName}OKR个人树调度任务
         Boolean bRetFlag = false;
         String retConent = "";
         CreateOkrPersonalTreeDataNameRespDto retData = new CreateOkrPersonalTreeDataNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_OKR_PERSONAL_TREE_DATA_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null && reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成构建三棵树当前叶子及上级目标调度名称
      * desc:undefined
      * gen by moon at 1/10/2023, 4:36:03 PM
      *
      **/
     @Trace(operationName = "M2生成构建三棵树当前叶子及上级目标调度名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public BuildThreeTreeCurrentLeafAndSuperiorTaskNameRespDto buildThreeTreeCurrentLeafAndSuperiorTaskName(BuildThreeTreeCurrentLeafAndSuperiorTaskNameReqDto reqDto) {
         //{targetContentName}：构建三棵树当前叶子及上级目标调度
         Boolean bRetFlag = false;
         String retConent = "";
         BuildThreeTreeCurrentLeafAndSuperiorTaskNameRespDto retData = new BuildThreeTreeCurrentLeafAndSuperiorTaskNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("BUILD_THREE_TREE_CURRENT_LEAF_AND_SUPERIOR_TASK_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null && reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成调度自动更新权重分任务名称
      * desc:undefined
      * gen by moon at 1/10/2023, 4:36:09 PM
      *
      **/
     @Trace(operationName = "M2生成调度自动更新权重分任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateTimingTaskAutoUpdateWeightScoreNameRespDto createTimingTaskAutoUpdateWeightScoreName(CreateTimingTaskAutoUpdateWeightScoreNameReqDto reqDto) {
         //{targetContentName}：下级内容目标周期权重分更新调度
         Boolean bRetFlag = false;
         String retConent = "";
         CreateTimingTaskAutoUpdateWeightScoreNameRespDto retData = new CreateTimingTaskAutoUpdateWeightScoreNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_TIMING_TASK_AUTO_UPDATE_WEIGHT_SCORE_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null && reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成调度生成汇报任务名称
      * desc:undefined
      * gen by moon at 1/10/2023, 4:36:14 PM
      *
      **/
     @Trace(operationName = "M2-生成调度生成汇报任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateReportDispatchNameRespDto createReportDispatchName(CreateReportDispatchNameReqDto reqDto) {
         //{cycleStandardName}{targetContentName}：调度生成汇报任务
         Boolean bRetFlag = false;
         String retConent = "";
         CreateReportDispatchNameRespDto retData = new CreateReportDispatchNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_REPORT_DISPATCH_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getCycleStandardName()!=null && reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(cycleStandardName,reqDto.getCycleStandardName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成多循环更新检查项祖先状态调度名称
      * desc:undefined
      * gen by moon at 1/10/2023, 4:36:19 PM
      *
      **/
     @Trace(operationName = "M2生成多循环更新检查项祖先状态调度名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ManyLoopUpdateCheckItemNodeStatusDispatchNameRespDto manyLoopUpdateCheckItemNodeStatusDispatchName(ManyLoopUpdateCheckItemNodeStatusDispatchNameReqDto reqDto) {
         //{targetContentName}：多循环更新检查项祖先状态调度
         Boolean bRetFlag = false;
         String retConent = "";
         ManyLoopUpdateCheckItemNodeStatusDispatchNameRespDto retData = new ManyLoopUpdateCheckItemNodeStatusDispatchNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("MANY_LOOP_UPDATE_CHECK_ITEM_NODE_STATUS_DISPATCH_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null && reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成删除目标内容基本信息调度任务名称
      * desc:undefined
      * gen by moon at 1/10/2023, 9:16:44 PM
      *
      **/
     @Trace(operationName = "M2生成删除目标内容基本信息调度任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateDeleteTargetContInfoTaskNameRespDto createDeleteTargetContInfoTaskName(CreateDeleteTargetContInfoTaskNameReqDto reqDto) {
         //{systemDateTime}删除目标内容基本信息调度任务
         Boolean bRetFlag = false;
         String retConent = "";
         CreateDeleteTargetContInfoTaskNameRespDto retData = new CreateDeleteTargetContInfoTaskNameRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_DELETE_TARGET_CONT_INFO_TASK_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String systemDateTime = "\\{systemDateTime}";
             if(reqDto.getSystemDateTime()!=null && reqDto.getSystemDateTime()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(systemDateTime,CommonFunctionHelper.date2Str(reqDto.getSystemDateTime()));
             }else{
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(systemDateTime,"---");
             }

             if(retConent!=null && !retConent.isEmpty()){
                 retConent = retConent.replaceAll("---","");
                 retConent = retConent.replaceAll("（）","");
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成权重或权重分未设置提示内容
      * desc:undefined
      * gen by moon at 1/26/2023, 11:40:41 AM
      *
      **/
     @Trace(operationName = "M2生成权重或权重分未设置提示内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WeightAndScoreNotSetStoryTipsRespDto weightAndScoreNotSetStoryTips(WeightAndScoreNotSetStoryTipsReqDto reqDto) {
         //对不起，{cycleStandardName}{cyclelAlias}没有设权重或权重分！请重新设置~
         Boolean bRetFlag = false;
         String retConent = "";
         WeightAndScoreNotSetStoryTipsRespDto retData = new WeightAndScoreNotSetStoryTipsRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WEIGHT_AND_SCORE_NOT_SET_STORY_TIPS");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String cyclelAlias = "\\{cyclelAlias}";
             if(reqDto.getCycleStandardName()!=null && reqDto.getCyclelAlias()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(cyclelAlias,reqDto.getCyclelAlias());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成权重总和不等于100故事提示
      * desc:undefined
      * gen by moon at 1/26/2023, 11:40:47 AM
      *
      **/
     @Trace(operationName = "M2生成权重总和不等于100故事提示")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WeightSummationUnequalHundredStoryTipsRespDto weightSummationUnequalHundredStoryTips(WeightSummationUnequalHundredStoryTipsReqDto reqDto) {
         //对不起，{cycleStandardName}{cyclelAlias}下级设置的权重总和不等于100！请重新设置。~
         Boolean bRetFlag = false;
         String retConent = "";
         WeightSummationUnequalHundredStoryTipsRespDto retData = new WeightSummationUnequalHundredStoryTipsRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WEIGHT_AND_SCORE_NOT_SET_STORY_TIPS");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String cyclelAlias = "\\{cyclelAlias}";
             if(reqDto.getCycleStandardName()!=null && reqDto.getCyclelAlias()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(cyclelAlias,reqDto.getCyclelAlias());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成权重分设置异常故事提示
      * desc:undefined
      * gen by moon at 1/26/2023, 11:40:52 AM
      *
      **/
     @Trace(operationName = "M2生成权重分设置异常故事提示")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WeightScoreSetAbnormalStoryTipsRespDto weightScoreSetAbnormalStoryTips(WeightScoreSetAbnormalStoryTipsReqDto reqDto) {
         //对不起，{cycleStandardName}{cyclelAlias}下级内容设置的权重分总和不等于上级目标权重分！请重新设置~。
         Boolean bRetFlag = false;
         String retConent = "";
         WeightScoreSetAbnormalStoryTipsRespDto retData = new WeightScoreSetAbnormalStoryTipsRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WEIGHT_AND_SCORE_NOT_SET_STORY_TIPS");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String cyclelAlias = "\\{cyclelAlias}";
             if(reqDto.getCycleStandardName()!=null && reqDto.getCyclelAlias()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(cyclelAlias,reqDto.getCyclelAlias());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成目标周期下未设置目标故事提示
      * desc:undefined
      * gen by moon at 1/26/2023, 11:40:58 AM
      *
      **/
     @Trace(operationName = "M2生成目标周期下未设置目标故事提示")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public TargetCycleBelowUnsetTargetStoryTipsRespDto targetCycleBelowUnsetTargetStoryTips(TargetCycleBelowUnsetTargetStoryTipsReqDto reqDto) {
         //对不起，{cycleStandardName}{cyclelAlias}工作周期下没有规划目标！请完整规划目标到工作周期~。
         Boolean bRetFlag = false;
         String retConent = "";
         TargetCycleBelowUnsetTargetStoryTipsRespDto retData = new TargetCycleBelowUnsetTargetStoryTipsRespDto();
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WEIGHT_AND_SCORE_NOT_SET_STORY_TIPS");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String cyclelAlias = "\\{cyclelAlias}";
             if(reqDto.getCycleStandardName()!=null && reqDto.getCyclelAlias()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(cyclelAlias,reqDto.getCyclelAlias());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成计算标准数据MQ调度任务名称
      * desc:undefined
      * gen by moon at 2/16/2023, 9:45:07 PM
      * 
      **/
     @Trace(operationName = "M2生成计算标准数据MQ调度任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateCalcTargetReportDataTaskNameRespDto createCalcTargetReportDataTaskName(CreateCalcTargetReportDataTaskNameReqDto reqDto) {
        //CREATE_CALC_TARGET_REPORT_DATA_TASK_NAME
         //{taskName}计算目标汇报数据调度任务
         CreateCalcTargetReportDataTaskNameRespDto retData = new CreateCalcTargetReportDataTaskNameRespDto();

         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_CALC_TARGET_REPORT_DATA_TASK_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String taskName = "\\{taskName}";
             if(reqDto.getTaskName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(taskName,reqDto.getTaskName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成托底更新目标内容父子状态调度任务名称
      * desc:undefined
      * gen by moon at 3/3/2023, 6:28:56 PM
      *
      **/
     @Trace(operationName = "M2-生成托底更新目标内容父子状态调度任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateTorrUpdateContParentStatePlanNameRespDto createTorrUpdateContParentStatePlanName(CreateTorrUpdateContParentStatePlanNameReqDto reqDto) {
         //CREATE_TORR_UPDATE_CONT_PARENT_STATE_PLAN_NAME
         //托底更新{targetContentName}：下级父子状态调度任务
         CreateTorrUpdateContParentStatePlanNameRespDto retData = new CreateTorrUpdateContParentStatePlanNameRespDto();

         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_TORR_UPDATE_CONT_PARENT_STATE_PLAN_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成平台托底更新目标内容父子状态调度任务名称
      * desc:undefined
      * gen by moon at 3/3/2023, 6:29:01 PM
      *
      **/
     @Trace(operationName = "M2-生成平台托底更新目标内容父子状态调度任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreatePlaTorrUpdateContParentStatePlanNameRespDto createPlaTorrUpdateContParentStatePlanName(CreatePlaTorrUpdateContParentStatePlanNameReqDto reqDto) {
         //CREATE_PLA_TORR_UPDATE_CONT_PARENT_STATE_PLAN_NAME
         //平台托底更新{targetContentName}：下级内容父子状态
         CreatePlaTorrUpdateContParentStatePlanNameRespDto retData = new CreatePlaTorrUpdateContParentStatePlanNameRespDto();

         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_PLA_TORR_UPDATE_CONT_PARENT_STATE_PLAN_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务自动汇报名称
      * desc:undefined
      * gen by moon at 3/3/2023, 11:29:07 PM
      * 
      **/
     @Trace(operationName = "M2生成汇报任务自动汇报名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateReportTaskAutoExecNameRespDto createReportTaskAutoExecName(CreateReportTaskAutoExecNameReqDto reqDto) {
         //CREATE_REPORT_TASK_AUTO_EXEC_NAME
         //{abbreviation}：汇报任务自动汇报调度
         CreateReportTaskAutoExecNameRespDto retData = new CreateReportTaskAutoExecNameRespDto();

         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_REPORT_TASK_AUTO_EXEC_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String abbreviation = "\\{abbreviation}";
             if(reqDto.getAbbreviation()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(abbreviation,reqDto.getAbbreviation());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成补偿目标内容检查项等调度名称
      * desc:undefined
      * gen by moon at 3/5/2023, 6:28:58 PM
      * 
      **/
     @Trace(operationName = "M2生成补偿目标内容检查项等调度名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateCompensationTargetContCheckEtcDisNameRespDto createCompensationTargetContCheckEtcDisName(CreateCompensationTargetContCheckEtcDisNameReqDto reqDto) {
         //CREATE_COMPENSATION_TARGET_CONT_CHECK_ETC_DIS_NAME
         //补偿{targetContentName}检查项等调度
         CreateCompensationTargetContCheckEtcDisNameRespDto retData = new CreateCompensationTargetContCheckEtcDisNameRespDto();

         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_COMPENSATION_TARGET_CONT_CHECK_ETC_DIS_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成向下更新目标设置等检查项状态调度名称
      * desc:undefined
      * gen by moon at 4/13/2023, 12:14:40 AM
      *
      **/
     @Trace(operationName = "M2生成向下更新目标设置等检查项状态调度名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateDownwardUpdateTargetSetCheckItemEtcStatePlanNameRespDto createDownwardUpdateTargetSetCheckItemEtcStatePlanName(CreateDownwardUpdateTargetSetCheckItemEtcStatePlanNameReqDto reqDto) {
         //CREATE_DOWNWARD_UPDATE_TARGET_SET_CHECK_ITEM_ETC_STATE_PLAN_NAME
         //向下更新“{targetContentName}”安排的指标目标设置检查项状态等
         CreateDownwardUpdateTargetSetCheckItemEtcStatePlanNameRespDto retData = new CreateDownwardUpdateTargetSetCheckItemEtcStatePlanNameRespDto();

         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_DOWNWARD_UPDATE_TARGET_SET_CHECK_ITEM_ETC_STATE_PLAN_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成工作周期更新切片
      * desc:undefined
      * gen by moon at 4/16/2023, 12:13:09 AM
      *
      **/
     @Trace(operationName = "M2-生成工作周期更新切片")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WorkCycleUpdateSliceRespDto workCycleUpdateSlice(WorkCycleUpdateSliceReqDto reqDto) {
         //WORK_CYCLE_UPDATE_SLICE
         //{parentSubMidCycleType}{customField1}{customField2}{customField3}
         WorkCycleUpdateSliceRespDto retData = new WorkCycleUpdateSliceRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WORK_CYCLE_UPDATE_SLICE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String parentSubMidCycleType = "\\{parentSubMidCycleType}";
             String customField1 = "\\{customField1}";
             String customField2 = "\\{customField2}";
             String customField3 = "\\{customField3}";
             if(reqDto.getParentSubMidCycleType()!=null &&reqDto.getCustomField1()!=null && reqDto.getCustomField2()!=null && reqDto.getCustomField3()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(parentSubMidCycleType,reqDto.getParentSubMidCycleType());
                 retConent = retConent.replaceAll(customField1,reqDto.getCustomField1());
                 retConent = retConent.replaceAll(customField2,reqDto.getCustomField2());
                 retConent = retConent.replaceAll(customField3,reqDto.getCustomField3());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:receptionService
      * name:约定出参：对象名称
      * desc:undefined
      * gen by moon at 4/28/2023, 3:50:16 PM
      *
      **/
     @Trace(operationName = "约定出参：对象名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public QueryOutputParametersDetailRespDto queryOutputParametersDetail(QueryOutputParametersDetailReqDto reqDto) {
        return BeanUtil.toBean(reqDto,QueryOutputParametersDetailRespDto.class);
      }
/**
      * code:generateSemanticInstance
      * name:M2生成修订目标值故事内容
      * desc:undefined
      * gen by moon at 5/13/2023, 5:02:35 AM
      *
      **/
     @Trace(operationName = "M2生成修订目标值故事内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ModifyTheTargetValueLogNameRespDto modifyTheTargetValueLogName(ModifyTheTargetValueLogNameReqDto reqDto) {
         //MODIFY_THE_TARGET_VALUE_LOG_NAME
         //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
         ModifyTheTargetValueLogNameRespDto retData = new ModifyTheTargetValueLogNameRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("MODIFY_THE_TARGET_VALUE_LOG_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String reviseSubjectContent = "\\{reviseSubjectContent}";
             String reviseBehaviorName = "\\{reviseBehaviorName}";
             String columnContent = "\\{columnContent}";
             if(reqDto.getReviseSubjectContent()!=null &&reqDto.getReviseBehaviorName()!=null && reqDto.getColumnContent()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent,reqDto.getReviseSubjectContent());
                 retConent = retConent.replaceAll(reviseBehaviorName,reqDto.getReviseBehaviorName());
                 retConent = retConent.replaceAll(columnContent,reqDto.getColumnContent());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成修订权重语义故事
      * desc:undefined
      * gen by moon at 5/13/2023, 5:02:40 AM
      *
      **/
     @Trace(operationName = "M2生成修订权重语义故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ModifyTheWeightLogNameRespDto modifyTheWeightLogName(ModifyTheWeightLogNameReqDto reqDto) {
         //MODIFY_THE_WEIGHT_LOG_NAME
         //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
         ModifyTheWeightLogNameRespDto retData = new ModifyTheWeightLogNameRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("MODIFY_THE_WEIGHT_LOG_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String reviseSubjectContent = "\\{reviseSubjectContent}";
             String reviseBehaviorName = "\\{reviseBehaviorName}";
             String columnContent = "\\{columnContent}";
             if(reqDto.getReviseSubjectContent()!=null &&reqDto.getReviseBehaviorName()!=null && reqDto.getColumnContent()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent,reqDto.getReviseSubjectContent());
                 retConent = retConent.replaceAll(reviseBehaviorName,reqDto.getReviseBehaviorName());
                 retConent = retConent.replaceAll(columnContent,reqDto.getColumnContent());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成修订重新计算标准数据任务名称
      * desc:undefined
      * gen by moon at 5/13/2023, 9:05:48 PM
      *
      **/
     @Trace(operationName = "M2生成修订重新计算标准数据任务名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReviseRecalculateDataTaskNameRespDto reviseRecalculateDataTaskName(ReviseRecalculateDataTaskNameReqDto reqDto) {
         //REVISE_RECALCULATE_DATA_TASK_NAME
         //{targetContentName}：修订重新计算标准数据任务
         ReviseRecalculateDataTaskNameRespDto retData = new ReviseRecalculateDataTaskNameRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REVISE_RECALCULATE_DATA_TASK_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成修订计划验收时间故事
      * desc:undefined
      * gen by moon at 5/17/2023, 3:41:32 AM
      * 
      **/
     @Trace(operationName = "M2生成修订计划验收时间故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ModifyReceiveTimeLogNameRespDto modifyReceiveTimeLogName(ModifyReceiveTimeLogNameReqDto reqDto) {
         //MODIFY_RECEIVE_TIME_LOG_NAME
         //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
         ModifyReceiveTimeLogNameRespDto retData = new ModifyReceiveTimeLogNameRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("MODIFY_RECEIVE_TIME_LOG_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String reviseSubjectContent = "\\{reviseSubjectContent}";
             String reviseBehaviorName = "\\{reviseBehaviorName}";
             String columnContent = "\\{columnContent}";
             if(reqDto.getReviseSubjectContent()!=null&&reqDto.getReviseBehaviorName()!=null&&reqDto.getColumnContent()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent,reqDto.getReviseSubjectContent());
                 retConent = retConent.replaceAll(reviseBehaviorName,reqDto.getReviseBehaviorName());
                 retConent = retConent.replaceAll(columnContent,reqDto.getColumnContent());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成修订目标周期名称语义故事
      * desc:undefined
      * gen by moon at 5/17/2023, 3:41:37 AM
      * 
      **/
     @Trace(operationName = "M2生成修订目标周期名称语义故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ModifyTargetCycleNameLogNameRespDto modifyTargetCycleNameLogName(ModifyTargetCycleNameLogNameReqDto reqDto) {
         //MODIFY_TARGET_CYCLE_NAME_LOG_NAME
         //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
         ModifyTargetCycleNameLogNameRespDto retData = new ModifyTargetCycleNameLogNameRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("MODIFY_TARGET_CYCLE_NAME_LOG_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String reviseSubjectContent = "\\{reviseSubjectContent}";
             String reviseBehaviorName = "\\{reviseBehaviorName}";
             String columnContent = "\\{columnContent}";
             if(reqDto.getReviseSubjectContent()!=null&&reqDto.getReviseBehaviorName()!=null&&reqDto.getColumnContent()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent,reqDto.getReviseSubjectContent());
                 retConent = retConent.replaceAll(reviseBehaviorName,reqDto.getReviseBehaviorName());
                 retConent = retConent.replaceAll(columnContent,reqDto.getColumnContent());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成修订指标分工设置语义故事
      * desc:undefined
      * gen by moon at 5/17/2023, 11:17:32 PM
      *
      **/
     @Trace(operationName = "M2生成修订指标分工设置语义故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ModifyObjtiveDivLogNameRespDto modifyObjtiveDivLogName(ModifyObjtiveDivLogNameReqDto reqDto) {
         //MODIFY_OBJTIVE_DIV_LOG_NAME
         //{reviseSubjectContent}{reviseBehaviorName}为{columnContent}
         ModifyObjtiveDivLogNameRespDto retData = new ModifyObjtiveDivLogNameRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("MODIFY_OBJTIVE_DIV_LOG_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String reviseSubjectContent = "\\{reviseSubjectContent}";
             String reviseBehaviorName = "\\{reviseBehaviorName}";
             String columnContent = "\\{columnContent}";
             if(reqDto.getReviseSubjectContent()!=null&&reqDto.getReviseBehaviorName()!=null&&reqDto.getColumnContent()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(reviseSubjectContent,reqDto.getReviseSubjectContent());
                 retConent = retConent.replaceAll(reviseBehaviorName,reqDto.getReviseBehaviorName());
                 retConent = retConent.replaceAll(columnContent,reqDto.getColumnContent());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成：邀请“ xx ” 加入小岛
      * desc:undefined
      * gen by moon at 5/31/2023, 6:08:33 PM
      *
      **/
     @Trace(operationName = "M2生成：邀请“ xx ” 加入小岛")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateGroupDefaultPromptMessageRespDto createGroupDefaultPromptMessage(CreateGroupDefaultPromptMessageReqDto reqDto) {
        //CREATE_GROUP_DEFAULT_PROMPT_MESSAGE
         //邀请{idCardName}加入小岛。
         CreateGroupDefaultPromptMessageRespDto retData = new CreateGroupDefaultPromptMessageRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_GROUP_DEFAULT_PROMPT_MESSAGE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             if(reqDto!=null&&reqDto.getIdCardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成“我是**”
      * desc:undefined
      * gen by moon at 5/31/2023, 6:08:34 PM
      *
      **/
     @Trace(operationName = "M2生成“我是**”")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public TwoPeopleChatDefaultPromptMessageRespDto twoPeopleChatDefaultPromptMessage(TwoPeopleChatDefaultPromptMessageReqDto reqDto) {
         //TWO_PEOPLE_CHAT_DEFAULT_PROMPT_MESSAGE
         //我是{idCardName}。
         TwoPeopleChatDefaultPromptMessageRespDto retData = new TwoPeopleChatDefaultPromptMessageRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("TWO_PEOPLE_CHAT_DEFAULT_PROMPT_MESSAGE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             if(reqDto!=null&&reqDto.getIdCardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成：多人被“ xx ” 移出小岛
      * desc:undefined
      * gen by moon at 5/31/2023, 6:08:35 PM
      *
      **/
     @Trace(operationName = "M2生成：多人被“ xx ” 移出小岛")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public KickOutMultDefaultPromptMessageRespDto kickOutMultDefaultPromptMessage(KickOutMultDefaultPromptMessageReqDto reqDto) {
         //KICK_OUT_SINGLE_DEFAULT_PROMPT_MESSAGE
         //被{idCardName}移出小岛。
         KickOutMultDefaultPromptMessageRespDto retData = new KickOutMultDefaultPromptMessageRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("KICK_OUT_SINGLE_DEFAULT_PROMPT_MESSAGE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             if(reqDto!=null&&reqDto.getIdCardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成：被“ xx ” 移出小岛
      * desc:undefined
      * gen by moon at 5/31/2023, 6:08:36 PM
      *
      **/
     @Trace(operationName = "M2生成：被“ xx ” 移出小岛 ")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public KickOutSingleDefaultPromptMessageRespDto kickOutSingleDefaultPromptMessage(KickOutSingleDefaultPromptMessageReqDto reqDto) {
         //KICK_OUT_MULT_DEFAULT_PROMPT_MESSAGE
         //多人被{idCardName}移出小岛。
         KickOutSingleDefaultPromptMessageRespDto retData = new KickOutSingleDefaultPromptMessageRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("KICK_OUT_MULT_DEFAULT_PROMPT_MESSAGE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             if(reqDto!=null&&reqDto.getIdCardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成 “ xx ” 邀请多人加入小岛
      * desc:undefined
      * gen by moon at 5/31/2023, 6:08:37 PM
      *
      **/
     @Trace(operationName = "M2生成 “ xx ” 邀请多人加入小岛")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateMultGroupDefaultPromptMessageRespDto createMultGroupDefaultPromptMessage(CreateMultGroupDefaultPromptMessageReqDto reqDto) {
         //CREATE_MULT_GROUP_DEFAULT_PROMPT_MESSAGE
         //{idCardName}邀请多人加入小岛。
         CreateMultGroupDefaultPromptMessageRespDto retData = new CreateMultGroupDefaultPromptMessageRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_MULT_GROUP_DEFAULT_PROMPT_MESSAGE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             if(reqDto!=null&&reqDto.getIdCardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成：“ xx ” 退出小岛
      * desc:undefined
      * gen by moon at 5/31/2023, 6:08:38 PM
      *
      **/
     @Trace(operationName = "M2生成：“ xx ” 退出小岛")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ActiveQuitDefaultPromptMessageRespDto activeQuitDefaultPromptMessage(ActiveQuitDefaultPromptMessageReqDto reqDto) {
       ///ACTIVE_QUIT_DEFAULT_PROMPT_MESSAGE
         //{idCardName}退出小岛。
         ActiveQuitDefaultPromptMessageRespDto retData = new ActiveQuitDefaultPromptMessageRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("ACTIVE_QUIT_DEFAULT_PROMPT_MESSAGE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             if(reqDto!=null&&reqDto.getIdCardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成全模板网格计算标准数据任务名称
      * desc:undefined
      * gen by moon at 6/2/2023, 2:35:04 PM
      *
      **/
     @Trace(operationName = "M2-生成全模板网格计算标准数据任务名称	")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public DispatchExecuteGridCalcTaskNameRespDto dispatchExecuteGridCalcTaskName(DispatchExecuteGridCalcTaskNameReqDto reqDto) {
        //DISPATCH_EXECUTE_GRID_CALC_TASK_NAME
         //{targetContentName}全模版网格计算标准数据任务
         DispatchExecuteGridCalcTaskNameRespDto retData = new DispatchExecuteGridCalcTaskNameRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("DISPATCH_EXECUTE_GRID_CALC_TASK_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             String cycleStandardName = "\\{cycleStandardName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成目标内容管理锁主键
      * desc:undefined
      * gen by moon at 6/26/2023, 9:48:25 PM
      * 
      **/
     @Trace(operationName = "M2生成目标内容管理锁主键")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public TargetContMgtKeyRespDto targetContMgtKey(TargetContMgtKeyReqDto reqDto) {
        //{evaluationTemplateId}{conEntityId}
         //TARGET_CONT_MGT_KEY
         TargetContMgtKeyRespDto retData = new TargetContMgtKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("TARGET_CONT_MGT_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String entityId = "\\{entityId}";
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             if(reqDto!=null&&reqDto.getEntityId()!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(entityId,reqDto.getEntityId());
                 retConent = retConent.replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成新增模板全内容计算异步锁名称
      * desc:undefined
      * gen by moon at 6/26/2023, 9:48:31 PM
      * 
      **/
     @Trace(operationName = "M2生成新增模板全内容计算异步锁名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public TempAllContentCalcLockKeyRespDto tempAllContentCalcLockKey(TempAllContentCalcLockKeyReqDto reqDto) {
         //ADD_TEMP_ALL_CONTENT_CALC_LOCK_KEY
         TempAllContentCalcLockKeyRespDto retData = new TempAllContentCalcLockKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("ADD_TEMP_ALL_CONTENT_CALC_LOCK_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成执行模板全内容计算异步锁名称
      * desc:undefined
      * gen by moon at 6/26/2023, 9:48:37 PM
      * 
      **/
     @Trace(operationName = "M2生成执行模板全内容计算异步锁名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ExecTempAllContentCalcLockKeyRespDto execTempAllContentCalcLockKey(ExecTempAllContentCalcLockKeyReqDto reqDto) {
         //EXEC_TEMP_ALL_CONTENT_CALC_LOCK_KEY
         ExecTempAllContentCalcLockKeyRespDto retData = new ExecTempAllContentCalcLockKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("EXEC_TEMP_ALL_CONTENT_CALC_LOCK_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成新增模版数据重计算异步锁名称
      * desc:undefined
      * gen by moon at 6/29/2023, 2:03:29 AM
      * 
      **/
     @Trace(operationName = "M2-生成新增模版数据重计算异步锁名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public AddTempAllContentRecalcLockKeyRespDto addTempAllContentRecalcLockKey(AddTempAllContentRecalcLockKeyReqDto reqDto) {
         //ADD_TEMP_ALL_CONTENT_RECALC_LOCK_KEY
         //addRecalc_{evaluationTemplateId}
         AddTempAllContentRecalcLockKeyRespDto retData = new AddTempAllContentRecalcLockKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("ADD_TEMP_ALL_CONTENT_RECALC_LOCK_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成增目标内容调度锁主键
      * desc:undefined
      * gen by moon at 6/30/2023, 10:39:55 PM
      *
      **/
     @Trace(operationName = "M2生成增目标内容调度锁主键")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public AddTargetContDispatchKeyRespDto addTargetContDispatchKey(AddTargetContDispatchKeyReqDto reqDto) {
         //ADD_TARGET_CONT_DISPATCH_KEY
         //dispatch_{evaluationTemplateId}{entityId}
         AddTargetContDispatchKeyRespDto retData = new AddTargetContDispatchKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("ADD_TARGET_CONT_DISPATCH_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             String entityId = "\\{entityId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retConent = retConent.replaceAll(entityId,reqDto.getEntityId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成全模版汇报任务锁名称
      * desc:undefined
      * gen by moon at 7/5/2023, 4:31:38 PM
      *
      **/
     @Trace(operationName = "M2生成全模版汇报任务锁名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public AddTempAllReportTaskLockKeyRespDto addTempAllReportTaskLockKey(AddTempAllReportTaskLockKeyReqDto reqDto) {
       // TODO ruizhe skai dong ; 7/5/2023, 4:31:38 PM

         //ADD_TEMP_ALL_REPORT_TASK_LOCK_KEY
        // addReportTask_{evaluationTemplateId}
         AddTempAllReportTaskLockKeyRespDto retData = new AddTempAllReportTaskLockKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("ADD_TEMP_ALL_REPORT_TASK_LOCK_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成高层下发指标锁主键
      * desc:undefined
      * gen by moon at 7/5/2023, 7:49:40 PM
      *
      **/
     @Trace(operationName = "M2生成高层下发指标锁主键")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public TopIusseObjLockKeyRespDto topIusseObjLockKey(TopIusseObjLockKeyReqDto reqDto) {
        //TOP_IUSSE_OBJ_LOCK_KEY
         //topIusseObj{evaluationTemplateId}
         TopIusseObjLockKeyRespDto retData = new TopIusseObjLockKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("TOP_IUSSE_OBJ_LOCK_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成中层下发指标锁主键
      * desc:undefined
      * gen by moon at 7/5/2023, 7:49:46 PM
      *
      **/
     @Trace(operationName = "M2生成中层下发指标锁主键")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public MidIusseObjLockKeyRespDto midIusseObjLockKey(MidIusseObjLockKeyReqDto reqDto) {
         //MID_IUSSE_OBJ_LOCK_KEY
         //midIusse{entityId}{evaluationTemplateId}
         MidIusseObjLockKeyRespDto retData = new MidIusseObjLockKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("MID_IUSSE_OBJ_LOCK_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             String entityId = "\\{entityId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retConent = retConent.replaceAll(entityId,reqDto.getEntityId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成基层下发指标锁主键
      * desc:undefined
      * gen by moon at 7/5/2023, 7:49:52 PM
      *
      **/
     @Trace(operationName = "M2生成基层下发指标锁主键")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public BasicIusseObjLockKeyRespDto basicIusseObjLockKey(BasicIusseObjLockKeyReqDto reqDto) {
         //BASIC_IUSSE_OBJ_LOCK_KEY
         //basicIusse{entityId}{evaluationTemplateId}
         BasicIusseObjLockKeyRespDto retData = new BasicIusseObjLockKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("BASIC_IUSSE_OBJ_LOCK_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             String entityId = "\\{entityId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retConent = retConent.replaceAll(entityId,reqDto.getEntityId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成高层返回第一步锁主键
      * desc:undefined
      * gen by moon at 7/5/2023, 7:49:58 PM
      *
      **/
     @Trace(operationName = "M2生成高层返回第一步锁主键")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public TopRollbackFirstKeyRespDto topRollbackFirstKey(TopRollbackFirstKeyReqDto reqDto) {
         //TOP_ROLLBACK_FIRST_KEY
         //topRollbackFirst{evaluationTemplateId}
         TopRollbackFirstKeyRespDto retData = new TopRollbackFirstKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("TOP_ROLLBACK_FIRST_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成中层返回上一步锁主键
      * desc:undefined
      * gen by moon at 7/5/2023, 7:50:04 PM
      *
      **/
     @Trace(operationName = "M2生成中层返回上一步锁主键")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public MidRollbackLastStepKeyRespDto midRollbackLastStepKey(MidRollbackLastStepKeyReqDto reqDto) {
         //MID_ROLLBACK_LAST_STEP_KEY
         //midRollbackLastStep{entityId}{evaluationTemplateId}
         MidRollbackLastStepKeyRespDto retData = new MidRollbackLastStepKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("MID_ROLLBACK_LAST_STEP_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             String entityId = "\\{entityId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retConent = retConent.replaceAll(entityId,reqDto.getEntityId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成基层返回第一步锁主键
      * desc:undefined
      * gen by moon at 7/5/2023, 7:50:09 PM
      *
      **/
     @Trace(operationName = "M2生成基层返回第一步锁主键")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public BasicRollbackFirstKeyRespDto basicRollbackFirstKey(BasicRollbackFirstKeyReqDto reqDto) {
         //BASIC_ROLLBACK_FIRST_KEY
         //basicRollbackFirst{entityId}{evaluationTemplateId}
         BasicRollbackFirstKeyRespDto retData = new BasicRollbackFirstKeyRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("BASIC_ROLLBACK_FIRST_KEY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String evaluationTemplateId = "\\{evaluationTemplateId}";
             String entityId = "\\{entityId}";
             if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                 retConent = retConent.replaceAll(entityId,reqDto.getEntityId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }

    /**
     * code:generateSemanticInstance
     * name:M2生成执行进度锁主键
     * desc:undefined
     * gen by moon at 7/5/2023, 10:26:32 PM
     *
     **/
    @Trace(operationName = "M2生成执行进度锁主键")
    @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
    public ExecuteProgressKeyRespDto executeProgressKey(ExecuteProgressKeyReqDto reqDto) {
        //EXECUTE_PROGRESS_KEY
        //progress{entityId}{evaluationTemplateId}
        ExecuteProgressKeyRespDto retData = new ExecuteProgressKeyRespDto();
        Boolean bRetFlag = false;
        String retConent = "";
        QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
        detailReq.setTemplateSemanticEngineCode("EXECUTE_PROGRESS_KEY");
        QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
        if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
            String evaluationTemplateId = "\\{evaluationTemplateId}";
            String entityId = "\\{entityId}";
            if(reqDto!=null&&reqDto.getEvaluationTemplateId()!=null){
                bRetFlag = true;
                retConent = detailRes.getTemplateEngineTemplate().replaceAll(evaluationTemplateId,reqDto.getEvaluationTemplateId());
                retConent = retConent.replaceAll(entityId,reqDto.getEntityId());
                retData.setObjectName(retConent);
            }

            if(bRetFlag){
                return retData;
            }

        }
        return retData;
    }
/**
      * code:generateSemanticInstance
      * name:M2生成内容会话通道名称
      * desc:undefined
      * gen by moon at 8/1/2023, 9:12:36 PM
      *
      **/
     @Trace(operationName = "M2生成内容会话通道名称")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ContentSessionChannelNameRespDto contentSessionChannelName(ContentSessionChannelNameReqDto reqDto) {
         //CONTENT_SESSION_CHANNEL_NAME
         //{cyclelAlias}
         ContentSessionChannelNameRespDto retData = new ContentSessionChannelNameRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CONTENT_SESSION_CHANNEL_NAME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cyclelAlias = "\\{cyclelAlias}";
             if(reqDto!=null&&reqDto.getCyclelAlias()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cyclelAlias,reqDto.getCyclelAlias());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报问答提问内容
      * desc:undefined
      * gen by moon at 8/6/2023, 12:28:35 PM
      *
      **/
     @Trace(operationName = "M2生成汇报问答提问内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportQaContentRespDto reportQaContent(ReportQaContentReqDto reqDto) {
         //CREATE_CONT_QA_MSG_CONTNET
         //基于“{objectName}”任务，{cycleStandardName}
         // 进度：{progressValue}{progressValueUnit}较上一周期{progressFromLastRatio}{progressValueUnit}
         // ，实际值：{actualValue}{actualValueUnit}较上一周期{fromLastTargetLiftRatio}{actualValueUnit}
         // ，达成度：{reach}{reachUnit}较上一周期{actualFromLastTimeRatio}{reachUnit}
         // ，汇报得分：{reportScoreValue}{reportScoreUnit}较上一周期{reportScoreFromLastRatio}{reportScoreUnit}。
         // 根据以上信息生成汇报内容
         ReportQaContentRespDto retData = new ReportQaContentRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_CONT_QA_MSG_CONTNET");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String objectName = "\\{objectName}";
             retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
             retConent = retConent.replaceAll(objectName,reqDto.getObjectName());
             if(reqDto.getProgressValue()!=null){
                 String progressValue = "\\{progressValue}";
                 String progressValueUnit = "\\{progressValueUnit}";
                 retConent = retConent.replaceAll(progressValue,String.valueOf(reqDto.getProgressValue()));
                 retConent = retConent.replaceAll(progressValueUnit,reqDto.getProgressValueUnit());
                 if(reqDto.getProgressFromLastRatio()!=null){
                     String progressFromLastRatio = "\\{progressFromLastRatio}";
                     retConent = retConent.replaceAll(progressFromLastRatio,String.valueOf(reqDto.getProgressFromLastRatio()));
                     retConent = retConent.replaceAll(progressValueUnit,String.valueOf(reqDto.getProgressValueUnit()));
                 }else{
                     String replaceKeyStr = "较上一周期\\{progressFromLastRatio}" + String.valueOf(reqDto.getProgressValueUnit());
                     retConent = retConent.replaceAll(replaceKeyStr,"");
                 }
             }else{
                 retConent = retConent.replaceAll("进度：\\{progressValue}\\{progressValueUnit}较上一周期\\{progressFromLastRatio}\\{progressValueUnit}，","");
             }

             if(reqDto.getActualValue()!=null){
                 String actualValue = "\\{actualValue}";
                 String actualValueUnit = "\\{actualValueUnit}";
                 retConent = retConent.replaceAll(actualValue,String.valueOf(reqDto.getActualValue()));
                 retConent = retConent.replaceAll(actualValueUnit,reqDto.getActualValueUnit());
                 if(reqDto.getFromLastTargetLiftRatio()!=null){
                     String fromLastTargetLiftRatio = "\\{fromLastTargetLiftRatio}";
                     retConent = retConent.replaceAll(fromLastTargetLiftRatio,String.valueOf(reqDto.getFromLastTargetLiftRatio()));
                     retConent = retConent.replaceAll(actualValueUnit,String.valueOf(reqDto.getActualValueUnit()));
                 }else{
                     String replaceKeyStr ="较上一周期\\{fromLastTargetLiftRatio}" + String.valueOf(reqDto.getActualValueUnit());
                     retConent = retConent.replaceAll(replaceKeyStr,"");
                 }
             }else{
                 retConent = retConent.replaceAll("实际值：\\{actualValue}\\{actualValueUnit}较上一周期\\{fromLastTargetLiftRatio}\\{actualValueUnit}，","");
             }

             if(reqDto.getReach()!=null){
                 String reach = "\\{reach}";
                 String reachUnit = "\\{reachUnit}";
                 retConent = retConent.replaceAll(reach,String.valueOf(reqDto.getReach()));
                 retConent = retConent.replaceAll(reachUnit,reqDto.getReachUnit());
                 if(reqDto.getActualFromLastTimeRatio()!=null){
                     String actualFromLastTimeRatio = "\\{actualFromLastTimeRatio}";
                     retConent = retConent.replaceAll(actualFromLastTimeRatio,String.valueOf(reqDto.getActualFromLastTimeRatio()));
                     retConent = retConent.replaceAll(reachUnit,String.valueOf(reqDto.getReachUnit()));
                 }else{
                     String replaceKeyStr ="较上一周期\\{actualFromLastTimeRatio}" + String.valueOf(reqDto.getReachUnit());
                     retConent = retConent.replaceAll(replaceKeyStr,"");
                 }
             }else{
                 retConent = retConent.replaceAll("达成度：\\{reach}\\{reachUnit}较上一周期\\{actualFromLastTimeRatio}\\{reachUnit}，","");
             }

             if(reqDto.getReportScoreValue()!=null){
                 String reportScoreValue = "\\{reportScoreValue}";
                 String reportScoreUnit = "\\{reportScoreUnit}";
                 retConent = retConent.replaceAll(reportScoreValue,String.valueOf(reqDto.getReportScoreValue()));
                 retConent = retConent.replaceAll(reportScoreUnit,reqDto.getReportScoreUnit());
                 if(reqDto.getReportScoreFromLastRatio()!=null){
                     String reportScoreFromLastRatio = "\\{reportScoreFromLastRatio}";
                     retConent = retConent.replaceAll(reportScoreFromLastRatio,String.valueOf(reqDto.getReportScoreFromLastRatio()));
                     retConent = retConent.replaceAll(reportScoreUnit,String.valueOf(reqDto.getReportScoreUnit()));
                 }else{
                     String replaceKeyStr ="较上一周期\\{reportScoreFromLastRatio}" + String.valueOf(reqDto.getReportScoreUnit());
                     retConent = retConent.replaceAll(replaceKeyStr,"");
                 }
             }else{
                 retConent = retConent.replaceAll("，汇报得分：\\{reportScoreValue}\\{reportScoreUnit}较上一周期\\{reportScoreFromLastRatio}\\{reportScoreUnit}","");
             }
             retData.setObjectName(retConent);
         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成分布式锁主题批次
      * desc:undefined
      * gen by moon at 10/1/2023, 12:34:07 AM
      *
      **/
     @Trace(operationName = "M2生成分布式锁主题批次")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public DistributedLockMotifBatchRespDto distributedLockMotifBatch(DistributedLockMotifBatchReqDto reqDto) {

         //DISTRIBUTED_LOCK_MOTIF_BATCH
         //{commPrimaryKey}{systemDateTime}
         DistributedLockMotifBatchRespDto retData = new DistributedLockMotifBatchRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("DISTRIBUTED_LOCK_MOTIF_BATCH");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String commPrimaryKey = "\\{commPrimaryKey}";
             String systemDateTime = "\\{systemDateTime}";
             if(reqDto!=null&&reqDto.getCommPrimaryKey()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(commPrimaryKey,reqDto.getCommPrimaryKey());
                 retConent = retConent.replaceAll(systemDateTime,CommonFunctionHelper.date2Str(reqDto.getSystemDateTime()));
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成新汇报任务消息标题
      * desc:undefined
      * gen by moon at 10/4/2023, 10:15:23 PM
      * 
      **/
     @Trace(operationName = "M2生成新汇报任务消息标题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public NewReportTaskMsgTitleRespDto newReportTaskMsgTitle(NewReportTaskMsgTitleReqDto reqDto) {
         //NEW_REPORT_TASK_MSG_TITLE
         //{cycleStandardName}的{targetContentName}目标有新汇报
         NewReportTaskMsgTitleRespDto retData = new NewReportTaskMsgTitleRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("NEW_REPORT_TASK_MSG_TITLE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成新汇报任务消息内容
      * desc:undefined
      * gen by moon at 10/4/2023, 10:15:29 PM
      * 
      **/
     @Trace(operationName = "M2生成新汇报任务消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public NewReportTaskMsgRespDto newReportTaskMsg(NewReportTaskMsgReqDto reqDto) {
         //NEW_REPORT_TASK_MSG
         //{cycleStandardName}的{targetContentName}目标有新汇报任务，请按时汇报~
         NewReportTaskMsgRespDto retData = new NewReportTaskMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("NEW_REPORT_TASK_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报即将逾期消息标题
      * desc:undefined
      * gen by moon at 10/4/2023, 10:15:34 PM
      * 
      **/
     @Trace(operationName = "M2生成汇报即将逾期消息标题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskWillOverdueMsgTitleRespDto reportTaskWillOverdueMsgTitle(ReportTaskWillOverdueMsgTitleReqDto reqDto) {
         //REPORT_TASK_WILL_OVERDUE_MSG_TITLE
         //{cycleStandardName}的{targetContentName}目标汇报即将逾期
         ReportTaskWillOverdueMsgTitleRespDto retData = new ReportTaskWillOverdueMsgTitleRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_WILL_OVERDUE_MSG_TITLE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报即将逾期消息内容
      * desc:undefined
      * gen by moon at 10/4/2023, 10:15:40 PM
      * 
      **/
     @Trace(operationName = "M2生成汇报即将逾期消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskWillOverdueMsgRespDto reportTaskWillOverdueMsg(ReportTaskWillOverdueMsgReqDto reqDto) {
         //REPORT_TASK_WILL_OVERDUE_MSG
         //{idCardName}你{cycleStandardName}的{targetContentName}目标汇报任务即将逾期，请及时汇报~
         ReportTaskWillOverdueMsgRespDto retData = new ReportTaskWillOverdueMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_WILL_OVERDUE_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报已逾期消息标题
      * desc:undefined
      * gen by moon at 10/4/2023, 10:15:46 PM
      * 
      **/
     @Trace(operationName = "M2生成汇报已逾期消息标题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskOverdueMsgTitleRespDto reportTaskOverdueMsgTitle(ReportTaskOverdueMsgTitleReqDto reqDto) {
         //{cycleStandardName}的{targetContentName}目标汇报已逾期
         //REPORT_TASK_OVERDUE_MSG_TITLE
         ReportTaskOverdueMsgTitleRespDto retData = new ReportTaskOverdueMsgTitleRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_OVERDUE_MSG_TITLE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报已逾期消息内容
      * desc:undefined
      * gen by moon at 10/4/2023, 10:15:52 PM
      * 
      **/
     @Trace(operationName = "M2生成汇报已逾期消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskOverdueMsgRespDto reportTaskOverdueMsg(ReportTaskOverdueMsgReqDto reqDto) {
         //{idCardName}你{cycleStandardName}的{targetContentName}目标汇报任务已逾期，要赶快汇报哦~
         //REPORT_TASK_OVERDUE_MSG
         ReportTaskOverdueMsgRespDto retData = new ReportTaskOverdueMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_OVERDUE_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成新目标安排消息标题
      * desc:undefined
      * gen by moon at 10/4/2023, 10:15:58 PM
      * 
      **/
     @Trace(operationName = "M2生成新目标安排消息标题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public NewTargetArrangeMsgTitleRespDto newTargetArrangeMsgTitle(NewTargetArrangeMsgTitleReqDto reqDto) {
         //新目标安排 {targetContentName}
         //NEW_TARGET_ARRANGE_MSG_TITLE
         NewTargetArrangeMsgTitleRespDto retData = new NewTargetArrangeMsgTitleRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("NEW_TARGET_ARRANGE_MSG_TITLE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成新目标安排消息内容
      * desc:undefined
      * gen by moon at 10/4/2023, 10:16:04 PM
      * 
      **/
     @Trace(operationName = "M2生成新目标安排消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public NewTargetArrangeMsgRespDto newTargetArrangeMsg(NewTargetArrangeMsgReqDto reqDto) {
         //{idCardName}你有新的目标安排：{targetContentName}
         //NEW_TARGET_ARRANGE_MSG
         NewTargetArrangeMsgRespDto retData = new NewTargetArrangeMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("NEW_TARGET_ARRANGE_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String dutyBodyName = "\\{dutyBodyName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getDutyBodyName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(dutyBodyName,reqDto.getDutyBodyName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务提交消息标题
      * desc:undefined
      * gen by moon at 10/10/2023, 1:45:49 AM
      *
      **/
     @Trace(operationName = "M2生成汇报任务提交消息标题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskMsgTitleRespDto reportTaskMsgTitle(ReportTaskMsgTitleReqDto reqDto) {
        //REPORT_TASK_MSG_TITLE
         //{targetContentName}...{cycleStandardName}汇报
         ReportTaskMsgTitleRespDto retData = new ReportTaskMsgTitleRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_MSG_TITLE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成催办目标安排消息内容
      * desc:undefined
      * gen by moon at 10/14/2023, 11:32:30 PM
      *
      **/
     @Trace(operationName = "M2生成催办目标安排消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public UrgeTargetArrangeMsgTempRespDto urgeTargetArrangeMsgTemp(UrgeTargetArrangeMsgTempReqDto reqDto) {
         //URGE_TARGET_ARRANGE_MSG_TEMP
         //{deptShortName}请尽快完成目标安排
         UrgeTargetArrangeMsgTempRespDto retData = new UrgeTargetArrangeMsgTempRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("URGE_TARGET_ARRANGE_MSG_TEMP");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String deptShortName = "\\{deptShortName}";
             if(reqDto!=null&&reqDto.getDeptShortName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(deptShortName,reqDto.getDeptShortName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务待评价消息标题
      * desc:undefined
      * gen by moon at 10/14/2023, 11:32:37 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务待评价消息标题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskToBeEvaluateedMsgTitleRespDto reportTaskToBeEvaluateedMsgTitle(ReportTaskToBeEvaluateedMsgTitleReqDto reqDto) {
         //REPORT_TASK_TO_BE_EVALUATEED_MSG_TITLE
         //{cycleStandardName}的{targetContentName}汇报已提交，请及时评价
         ReportTaskToBeEvaluateedMsgTitleRespDto retData = new ReportTaskToBeEvaluateedMsgTitleRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_TO_BE_EVALUATEED_MSG_TITLE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成中基层催办目标安排消息
      * desc:undefined
      * gen by moon at 10/14/2023, 11:32:43 PM
      *
      **/
     @Trace(operationName = "M2生成中基层催办目标安排消息")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public MidBasicUrgeTargetArrangeMsgTempRespDto midBasicUrgeTargetArrangeMsgTemp(MidBasicUrgeTargetArrangeMsgTempReqDto reqDto) {
         //MID_BASIC_URGE_TARGET_ARRANGE_MSG_TEMP
         //{deptShortName}你部门有{comNumField}个目标未安排，请尽快完成~
         MidBasicUrgeTargetArrangeMsgTempRespDto retData = new MidBasicUrgeTargetArrangeMsgTempRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("MID_BASIC_URGE_TARGET_ARRANGE_MSG_TEMP");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String deptShortName = "\\{deptShortName}";
             String comNumField = "\\{comNumField}";
             if(reqDto!=null&&reqDto.getDeptShortName()!=null&&reqDto.getComNumField()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(deptShortName,reqDto.getDeptShortName());
                 retConent = retConent.replaceAll(comNumField,String.valueOf(reqDto.getComNumField()));
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务待审核消息标题
      * desc:undefined
      * gen by moon at 10/14/2023, 11:32:49 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务待审核消息标题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskToBeExamineMsgTitleRespDto reportTaskToBeExamineMsgTitle(ReportTaskToBeExamineMsgTitleReqDto reqDto) {
         //REPORT_TASK_TO_BE_EXAMINE_MSG_TITLE
         //{cycleStandardName}的{targetContentName}评价已完成，请及时审核
         ReportTaskToBeExamineMsgTitleRespDto retData = new ReportTaskToBeExamineMsgTitleRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_TO_BE_EXAMINE_MSG_TITLE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务待审核消息内容
      * desc:undefined
      * gen by moon at 10/14/2023, 11:32:55 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务待审核消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskToBeExamineMsgRespDto reportTaskToBeExamineMsg(ReportTaskToBeExamineMsgReqDto reqDto) {
         //REPORT_TASK_TO_BE_EXAMINE_MSG
         //{cycleStandardName}的{targetContentName}目标汇报任务已完成，该汇报任务的审核人及时处理
         ReportTaskToBeExamineMsgRespDto retData = new ReportTaskToBeExamineMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_TO_BE_EXAMINE_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务审核驳回消息标题
      * desc:undefined
      * gen by moon at 10/14/2023, 11:33:01 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务审核驳回消息标题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskRejectMsgTitleRespDto reportTaskRejectMsgTitle(ReportTaskRejectMsgTitleReqDto reqDto) {
         //REPORT_TASK_REJECT_MSG_TITLE
         //{cycleStandardName}的{targetContentName}汇报被驳回，请及时处理
         ReportTaskRejectMsgTitleRespDto retData = new ReportTaskRejectMsgTitleRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_REJECT_MSG_TITLE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务审核驳回内容
      * desc:undefined
      * gen by moon at 10/14/2023, 11:33:07 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务审核驳回内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskRejectMsgRespDto reportTaskRejectMsg(ReportTaskRejectMsgReqDto reqDto) {
         //REPORT_TASK_REJECT_MSG
         //{cycleStandardName}的{targetContentName}汇报任务被驳回，请及时处理。驳回原因：{reportTaskRejectReason}。
         ReportTaskRejectMsgRespDto retData = new ReportTaskRejectMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_REJECT_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             String reportTaskRejectReason = "\\{reportTaskRejectReason}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 if(reqDto.getReportTaskRejectReason()!=null){
                     retConent = retConent.replaceAll(reportTaskRejectReason,reqDto.getReportTaskRejectReason());
                 }else{
                     retConent = retConent.replaceAll(reportTaskRejectReason,"");
                 }
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成修改目标值消息
      * desc:undefined
      * gen by moon at 10/14/2023, 11:33:13 PM
      *
      **/
     @Trace(operationName = "M2生成修改目标值消息")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public UpdateTargetValueMsgTempRespDto updateTargetValueMsgTemp(UpdateTargetValueMsgTempReqDto reqDto) {
         //UPDATE_TARGET_VALUE_MSG_TEMP
         //{idCardName}负责的{targetContentName}的目标值有调整，请检查确认~
         UpdateTargetValueMsgTempRespDto retData = new UpdateTargetValueMsgTempRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("UPDATE_TARGET_VALUE_MSG_TEMP");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getIdCardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务待评价消息内容
      * desc:undefined
      * gen by moon at 10/15/2023, 6:09:07 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务待评价消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskToBeEvaluateedMsgRespDto reportTaskToBeEvaluateedMsg(ReportTaskToBeEvaluateedMsgReqDto reqDto) {
         //REPORT_TASK_TO_BE_EVALUATEED_MSG
         //{cycleStandardName}的{targetContentName}目标汇报任务已提交，该汇报任务的评价人及时处理
         ReportTaskToBeEvaluateedMsgRespDto retData = new ReportTaskToBeEvaluateedMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_TO_BE_EVALUATEED_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成websocket消息主题
      * desc:undefined
      * gen by moon at 10/20/2023, 9:25:22 AM
      *
      **/
     @Trace(operationName = "M2-生成websocket消息主题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WebsocketMsgThemeRespDto websocketMsgTheme(WebsocketMsgThemeReqDto reqDto) {
         //WEBSOCKET_MSG_THEME
         //{originalRoleMemberId}messageTheme
         WebsocketMsgThemeRespDto retData = new WebsocketMsgThemeRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WEBSOCKET_MSG_THEME");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String originalRoleMemberId = "\\{originalRoleMemberId}";
             if(reqDto!=null&&reqDto.getOriginalRoleMemberId()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(originalRoleMemberId,reqDto.getOriginalRoleMemberId());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务提醒消息标题
      * desc:undefined
      * gen by moon at 10/22/2023, 7:21:08 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务提醒消息标题")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskRemindMsgTitleRespDto reportTaskRemindMsgTitle(ReportTaskRemindMsgTitleReqDto reqDto) {
         //{cycleStandardName}的{targetContentName}请及时汇报
         //REPORT_TASK_REMIND_MSG_TITLE
         ReportTaskRemindMsgTitleRespDto retData = new ReportTaskRemindMsgTitleRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_REMIND_MSG_TITLE");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
        return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务提醒消息内容
      * desc:undefined
      * gen by moon at 10/22/2023, 7:21:15 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务提醒消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ReportTaskRemindMsgRespDto reportTaskRemindMsg(ReportTaskRemindMsgReqDto reqDto) {
         //{cycleStandardName}的{targetContentName}还未汇报完成，请及时汇报~
         //REPORT_TASK_REMIND_MSG
         ReportTaskRemindMsgRespDto retData = new ReportTaskRemindMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REPORT_TASK_REMIND_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:invokeTemplateSemantic
      * name:M2生成加预算流水业务故事
      * desc:undefined
      * gen by moon at 11/6/2023, 5:56:43 PM
      *
      **/
     @Trace(operationName = "M2生成加预算流水业务故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateAddBudgetStoryRespDto createAddBudgetStory(CreateAddBudgetStoryReqDto reqDto) {
       //CREATE_ADD_BUDGET_STORY
         //{idCardName}减少{targetContentName}预算
         CreateAddBudgetStoryRespDto retData = new CreateAddBudgetStoryRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_ADD_BUDGET_STORY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             String idCardName = "\\{idCardName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null&&reqDto.getIdCardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:invokeTemplateSemantic
      * name:M2生成减预算流水业务故事
      * desc:undefined
      * gen by moon at 11/6/2023, 5:56:51 PM
      *
      **/
     @Trace(operationName = "M2生成减预算流水业务故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CreateSubTractBudgetStoryRespDto createSubTractBudgetStory(CreateSubTractBudgetStoryReqDto reqDto) {
         //CREATE_SUBTRACT_BUDGET_STORY
         //{idCardName}减少{targetContentName}预算
         CreateSubTractBudgetStoryRespDto retData = new CreateSubTractBudgetStoryRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CREATE_SUBTRACT_BUDGET_STORY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             String idCardName = "\\{idCardName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null&&reqDto.getIdCardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成预算到账账单流水业务故事
      * desc:undefined
      * gen by moon at 11/6/2023, 5:56:59 PM
      *
      **/
     @Trace(operationName = "M2生成预算到账账单流水业务故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public BudgetArrivalStoryRespDto budgetArrivalStory(BudgetArrivalStoryReqDto reqDto) {
         //BUDGET_ARRIVAL_STORY
         //{targetContentName}资金到账
         BudgetArrivalStoryRespDto retData = new BudgetArrivalStoryRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("BUDGET_ARRIVAL_STORY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成费用支出流水业务故事
      * desc:undefined
      * gen by moon at 11/6/2023, 5:57:08 PM
      *
      **/
     @Trace(operationName = "M2-生成费用支出流水业务故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ChargeExpenditureStoryRespDto chargeExpenditureStory(ChargeExpenditureStoryReqDto reqDto) {
         //CHARGE_EXPENDITURE_STORY
         //{accountSubjectName}支出
         ChargeExpenditureStoryRespDto retData = new ChargeExpenditureStoryRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("CHARGE_EXPENDITURE_STORY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String accountSubjectName = "\\{accountSubjectName}";
             if(reqDto!=null&&reqDto.getAccountSubjectName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(accountSubjectName,reqDto.getAccountSubjectName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成提醒签收工作任务消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:34:03 PM
      * 
      **/
     @Trace(operationName = "M2生成提醒签收工作任务消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public RemindSignWorkTaskMsgRespDto remindSignWorkTaskMsg(RemindSignWorkTaskMsgReqDto reqDto) {
         //您的工作任务：{targetContentName}还未签收，请及时处理。
         //REMIND_SIGN_WORK_TASK_MSG
         RemindSignWorkTaskMsgRespDto retData = new RemindSignWorkTaskMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REMIND_SIGN_WORK_TASK_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成督办工作任务消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:34:10 PM
      * 
      **/
     @Trace(operationName = "M2-生成督办工作任务消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public RemindHandleWorkTaskMsgRespDto remindHandleWorkTaskMsg(RemindHandleWorkTaskMsgReqDto reqDto) {
         //您的工作任务：{targetContentName}还未完成，请及时处理。
         //REMIND_HANDLE_WORK_TASK_MSG
         RemindHandleWorkTaskMsgRespDto retData = new RemindHandleWorkTaskMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REMIND_HANDLE_WORK_TASK_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成督办问题消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:34:16 PM
      * 
      **/
     @Trace(operationName = "M2生成督办问题消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public RemindHandleProblemMsgRespDto remindHandleProblemMsg(RemindHandleProblemMsgReqDto reqDto) {
         //您的问题：{targetContentName}还未解决，请及时处理。
         //REMIND_HANDLE_PROBLEM_MSG
         RemindHandleProblemMsgRespDto retData = new RemindHandleProblemMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("REMIND_HANDLE_PROBLEM_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成待签收工作任务消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:34:22 PM
      * 
      **/
     @Trace(operationName = "M2-生成待签收工作任务消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public GenerateToBeSignedWorkTaskMsgRespDto generateToBeSignedWorkTaskMsg(GenerateToBeSignedWorkTaskMsgReqDto reqDto) {
         //您有新的工作任务：{targetContentName}，请及时签收。
         //GENERATE_TO_BE_SIGNED_WORK_TASK_MSG
         GenerateToBeSignedWorkTaskMsgRespDto retData = new GenerateToBeSignedWorkTaskMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("GENERATE_TO_BE_SIGNED_WORK_TASK_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成进行中工作任务消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:34:28 PM
      * 
      **/
     @Trace(operationName = "M2-生成进行中工作任务消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public GenerateOngoingWorkTaskMsgRespDto generateOngoingWorkTaskMsg(GenerateOngoingWorkTaskMsgReqDto reqDto) {
         //您有新的工作任务：{targetContentName}，请及时处理。
         //GENERATE_ONGOING_WORK_TASK_MSG
         GenerateOngoingWorkTaskMsgRespDto retData = new GenerateOngoingWorkTaskMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("GENERATE_ONGOING_WORK_TASK_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成工作任务即将逾期消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:34:35 PM
      * 
      **/
     @Trace(operationName = "M2-生成工作任务即将逾期消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WorkTaskWillOverdueMsgRespDto workTaskWillOverdueMsg(WorkTaskWillOverdueMsgReqDto reqDto) {
         //您的工作任务：{targetContentName}即将逾期，请及时处理。
         //WORK_TASK_WILL_OVERDUE_MSG
         WorkTaskWillOverdueMsgRespDto retData = new WorkTaskWillOverdueMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WORK_TASK_WILL_OVERDUE_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成工作任务已逾期消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:34:41 PM
      * 
      **/
     @Trace(operationName = "M2-生成工作任务已逾期消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WorkTaskOverdueMsgRespDto workTaskOverdueMsg(WorkTaskOverdueMsgReqDto reqDto) {
         //您的工作任务：{targetContentName}已逾期，请赶快处理。
         //WORK_TASK_OVERDUE_MSG
         WorkTaskOverdueMsgRespDto retData = new WorkTaskOverdueMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WORK_TASK_OVERDUE_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成问题消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:34:47 PM
      * 
      **/
     @Trace(operationName = "M2-生成问题消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public GenerateProblemMsgRespDto generateProblemMsg(GenerateProblemMsgReqDto reqDto) {
         //您的问题：{targetContentName}即将超时，请及时处理。
         //GENERATE_PROBLEM_MSG
         GenerateProblemMsgRespDto retData = new GenerateProblemMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("GENERATE_PROBLEM_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成问题即将超时消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:34:54 PM
      * 
      **/
     @Trace(operationName = "M2-生成问题即将超时消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ProblemWillOvertimeMsgRespDto problemWillOvertimeMsg(ProblemWillOvertimeMsgReqDto reqDto) {
         //您的问题：{targetContentName}即将超时，请及时处理。
         //PROBLEM_WILL_OVERTIME_MSG
         ProblemWillOvertimeMsgRespDto retData = new ProblemWillOvertimeMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("PROBLEM_WILL_OVERTIME_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成问题已超时消息内容
      * desc:undefined
      * gen by moon at 11/8/2023, 3:35:00 PM
      * 
      **/
     @Trace(operationName = "M2-生成问题已超时消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ProblemOvertimeMsgRespDto problemOvertimeMsg(ProblemOvertimeMsgReqDto reqDto) {
         //您的问题：{targetContentName}已超时，请赶快处理。
         //PROBLEM_OVERTIME_MSG
         ProblemOvertimeMsgRespDto retData = new ProblemOvertimeMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("PROBLEM_OVERTIME_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成工作任务汇报消息内容
      * desc:undefined
      * gen by moon at 11/17/2023, 10:17:29 PM
      *
      **/
     @Trace(operationName = "M2-生成工作任务汇报消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WorkTaskReportMsgRespDto workTaskReportMsg(WorkTaskReportMsgReqDto reqDto) {
         //WORK_TASK_REPORT_MSG
         //“{targetContentTitleName}”工作任务进度为{comNumField}。
         //{targetContentName}
         WorkTaskReportMsgRespDto retData = new WorkTaskReportMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WORK_TASK_REPORT_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentTitleName = "\\{targetContentTitleName}";
             String comNumField = "\\{comNumField}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getTargetContentTitleName()!=null&&reqDto.getComNumField()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentTitleName,reqDto.getTargetContentTitleName());
                 retConent = retConent.replaceAll(comNumField,String.valueOf(reqDto.getComNumField()));
                 if(reqDto.getTargetContentName()!=null){
                     retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 }
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成下发公文语义故事
      * desc:undefined
      * gen by moon at 11/17/2023, 10:17:36 PM
      *
      **/
     @Trace(operationName = "M2生成下发公文语义故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public IssueOffcialDocStoryRespDto issueOffcialDocStory(IssueOffcialDocStoryReqDto reqDto) {
         //ISSUE_OFFCIAL_DOC_STORY
         //{deptShortName} {idCardName}下发公文：《{objectName}》，请注意查收并确认是否有工作安排。
         //{targetContentName}
         IssueOffcialDocStoryRespDto retData = new IssueOffcialDocStoryRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("ISSUE_OFFCIAL_DOC_STORY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String deptShortName = "\\{deptShortName}";
             String idCardName = "\\{idCardName}";
             String objectName = "\\{objectName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getDeptShortName()!=null&&reqDto.getIdCardName()!=null&&reqDto.getObjectName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(deptShortName,reqDto.getDeptShortName());
                 retConent = retConent.replaceAll(idCardName,reqDto.getIdCardName());
                 retConent = retConent.replaceAll(objectName,reqDto.getObjectName());
                 if(reqDto.getTargetContentName()!=null){
                     retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 }
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成公文工作任务安排指令故事
      * desc:undefined
      * gen by moon at 11/19/2023, 4:36:55 AM
      *
      **/
     @Trace(operationName = "M2生成公文工作任务安排指令故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ArrangeWorkTaskInstructStoryRespDto arrangeWorkTaskInstructStory(ArrangeWorkTaskInstructStoryReqDto reqDto) {
         //ARRANGE_WORK_TASK_INSTRUCT_STORY
         //{idCardName}下发一份公文《{objectName}》，需要您工作任务安排。请按要求尽快落实，以免耽误工作！
         //{targetContentName}
         ArrangeWorkTaskInstructStoryRespDto retData = new ArrangeWorkTaskInstructStoryRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("ARRANGE_WORK_TASK_INSTRUCT_STORY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String objectName = "\\{objectName}";
             if(reqDto!=null&&reqDto.getIdCardName()!=null&&reqDto.getObjectName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retConent = retConent.replaceAll(objectName,reqDto.getObjectName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成督办任务安排消息语义故事
      * desc:undefined
      * gen by moon at 11/22/2023, 9:06:32 PM
      * 
      **/
     @Trace(operationName = "M2生成督办任务安排消息语义故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public SuperviseTaskArrangeMsgStoryRespDto superviseTaskArrangeMsgStory(SuperviseTaskArrangeMsgStoryReqDto reqDto) {
         //SUPERVISE_TASK_ARRANGE_MSG_STORY
         //请按要求尽快落实《{objectName}》公文的工作任务安排，以免耽误工作！
         SuperviseTaskArrangeMsgStoryRespDto retData = new SuperviseTaskArrangeMsgStoryRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("SUPERVISE_TASK_ARRANGE_MSG_STORY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String objectName = "\\{objectName}";
             if(reqDto!=null&&reqDto.getObjectName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName,reqDto.getObjectName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成工作任务xx天后开始文案
      * desc:undefined
      * gen by moon at 11/28/2023, 7:50:25 PM
      *
      **/
     @Trace(operationName = "M2-生成工作任务xx天后开始文案	")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WorkTaskToStartDaysRespDto workTaskToStartDays(WorkTaskToStartDaysReqDto reqDto) {
         //WORK_TASK_TO_START_DAYS
         //{timeDiffDays}天后开始
         WorkTaskToStartDaysRespDto retData = new WorkTaskToStartDaysRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WORK_TASK_TO_START_DAYS");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String timeDiffDays = "\\{timeDiffDays}";
             if(reqDto!=null&&reqDto.getTimeDiffDays()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(timeDiffDays,String.valueOf(reqDto.getTimeDiffDays()));
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成工作任务提前xx天完成文案
      * desc:undefined
      * gen by moon at 11/28/2023, 7:50:31 PM
      *
      **/
     @Trace(operationName = "M2-生成工作任务提前xx天完成文案	")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WorkTaskFinishAheadDaysRespDto workTaskFinishAheadDays(WorkTaskFinishAheadDaysReqDto reqDto) {
         //WORK_TASK_FINISH_AHEAD_DAYS
         //提前{timeDiffDays}天完成
         WorkTaskFinishAheadDaysRespDto retData = new WorkTaskFinishAheadDaysRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WORK_TASK_FINISH_AHEAD_DAYS");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String timeDiffDays = "\\{timeDiffDays}";
             if(reqDto!=null&&reqDto.getTimeDiffDays()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(timeDiffDays,String.valueOf(reqDto.getTimeDiffDays()));
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成工作任务逾期xx天完成文案
      * desc:undefined
      * gen by moon at 11/28/2023, 7:50:38 PM
      *
      **/
     @Trace(operationName = "M2-生成工作任务逾期xx天完成文案")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WorkTaskFinishOverdueDaysRespDto workTaskFinishOverdueDays(WorkTaskFinishOverdueDaysReqDto reqDto) {
         //WORK_TASK_FINISH_OVERDUE_DAYS
         //逾期{timeDiffDays}天完成
         WorkTaskFinishOverdueDaysRespDto retData = new WorkTaskFinishOverdueDaysRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WORK_TASK_FINISH_OVERDUE_DAYS");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String timeDiffDays = "\\{timeDiffDays}";
             if(reqDto!=null&&reqDto.getTimeDiffDays()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(timeDiffDays,String.valueOf(reqDto.getTimeDiffDays()));
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2组装指令模板提问内容
      * desc:undefined
      * gen by moon at 12/9/2023, 3:24:43 PM
      *
      **/
     @Trace(operationName = "M2组装指令模板提问内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public AssemblyInstructionQusContTempRespDto assemblyInstructionQusContTemp(AssemblyInstructionQusContTempReqDto reqDto) {
         //ASSEMBLY_INSTRUCTION_QUS_CONT_TEMP
         //{content}{instructionTemplate}
         AssemblyInstructionQusContTempRespDto retData = new AssemblyInstructionQusContTempRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("ASSEMBLY_INSTRUCTION_QUS_CONT_TEMP");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String content = "\\{content}";
             String instructionTemplate = "\\{instructionTemplate}";
             if(reqDto!=null&&reqDto.getContent()!=null&&reqDto.getInstructionTemplate()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(content,reqDto.getContent());
                 retConent = retConent.replaceAll(instructionTemplate,reqDto.getInstructionTemplate());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2组织强提醒提问内容
      * desc:undefined
      * gen by moon at 12/9/2023, 3:24:49 PM
      *
      **/
     @Trace(operationName = "M2组织强提醒提问内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public AssemblyStrongReminderQusContTempRespDto assemblyStrongReminderQusContTemp(AssemblyStrongReminderQusContTempReqDto reqDto) {
         //STRONG_REMINDER_QUESTION_CONTENT
         //{strongReminderBasicCopy}{strongReminderContent}
         AssemblyStrongReminderQusContTempRespDto retData = new AssemblyStrongReminderQusContTempRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("STRONG_REMINDER_QUESTION_CONTENT");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String strongReminderBasicCopy = "\\{strongReminderBasicCopy}";
             String strongReminderContent = "\\{strongReminderContent}";
             if(reqDto!=null&&reqDto.getStrongReminderContent()!=null&&reqDto.getStrongReminderBasicCopy()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(strongReminderBasicCopy,reqDto.getStrongReminderBasicCopy());
                 retConent = retConent.replaceAll(strongReminderContent,reqDto.getStrongReminderContent());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2-生成工作任务失败消息内容
      * desc:undefined
      * gen by moon at 12/9/2023, 9:13:02 PM
      * 
      **/
     @Trace(operationName = "M2-生成工作任务失败消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WorkTaskFailureMsgRespDto workTaskFailureMsg(WorkTaskFailureMsgReqDto reqDto) {
         //WORK_TASK_FAILURE_MSG
         //{idCardName}的工作任务：{targetContentName}已失败。
         WorkTaskFailureMsgRespDto retData = new WorkTaskFailureMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WORK_TASK_FAILURE_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String idCardName = "\\{idCardName}";
             String targetContentName = "\\{targetContentName}";
             if(reqDto!=null&&reqDto.getIdCardName()!=null&&reqDto.getTargetContentName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(idCardName,reqDto.getIdCardName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成下发通知语义故事
      * desc:undefined
      * gen by moon at 12/15/2023, 2:23:38 PM
      *
      **/
     @Trace(operationName = "M2生成下发通知语义故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public IssueNotificationStoryRespDto issueNotificationStory(IssueNotificationStoryReqDto reqDto) {
         //ISSUE_NOTIFICATION_STORY
         //新通知：《{objectName}》，请注意查收。
         IssueNotificationStoryRespDto retData = new IssueNotificationStoryRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("ISSUE_NOTIFICATION_STORY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String objectName = "\\{objectName}";
             if(reqDto!=null&&reqDto.getObjectName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName,reqDto.getObjectName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成工作任务小结语义故事
      * desc:undefined
      * gen by moon at 12/23/2023, 11:06:26 PM
      *
      **/
     @Trace(operationName = "M2生成工作任务小结语义故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public WorkTaskSummarySemanticStoryRespDto workTaskSummarySemanticStory(WorkTaskSummarySemanticStoryReqDto reqDto) {
         //WORK_TASK_SUMMARY_SEMANTIC_STORY
         //{cycleStandardName}{taskName}小结
         WorkTaskSummarySemanticStoryRespDto retData = new WorkTaskSummarySemanticStoryRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("WORK_TASK_SUMMARY_SEMANTIC_STORY");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String cycleStandardName = "\\{cycleStandardName}";
             String taskName = "\\{taskName}";
             if(reqDto!=null&&reqDto.getCycleStandardName()!=null&&reqDto.getTaskName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retConent = retConent.replaceAll(taskName,reqDto.getTaskName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务问题总结消息内容
      * desc:undefined
      * gen by moon at 12/23/2023, 11:07:11 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务问题总结消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public SubmitReportTaskSummaryMsgRespDto submitReportTaskSummaryMsg(SubmitReportTaskSummaryMsgReqDto reqDto) {
         //SUBMIT_REPORT_TASK_SUMMARY_MSG
         //{objectName}({targetContentName}{cycleStandardName}汇报)
         SubmitReportTaskSummaryMsgRespDto retData = new SubmitReportTaskSummaryMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("SUBMIT_REPORT_TASK_SUMMARY_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String objectName = "\\{objectName}";
             String targetContentName = "\\{targetContentName}";
             String cycleStandardName = "\\{cycleStandardName}";
             if(reqDto!=null&&reqDto.getObjectName()!=null&&reqDto.getTargetContentName()!=null&&reqDto.getCycleStandardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName,reqDto.getObjectName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务解决思路消息内容
      * desc:undefined
      * gen by moon at 12/23/2023, 11:07:19 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务解决思路消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public SubmitReportTaskSolutionIdeaMsgRespDto submitReportTaskSolutionIdeaMsg(SubmitReportTaskSolutionIdeaMsgReqDto reqDto) {
         //SUBMIT_REPORT_TASK_SOLUTION_IDEA_MSG
         //{objectName}({targetContentName}{cycleStandardName}汇报)
         SubmitReportTaskSolutionIdeaMsgRespDto retData = new SubmitReportTaskSolutionIdeaMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("SUBMIT_REPORT_TASK_SOLUTION_IDEA_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String objectName = "\\{objectName}";
             String targetContentName = "\\{targetContentName}";
             String cycleStandardName = "\\{cycleStandardName}";
             if(reqDto!=null&&reqDto.getObjectName()!=null&&reqDto.getTargetContentName()!=null&&reqDto.getCycleStandardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName,reqDto.getObjectName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务改进建议消息内容
      * desc:undefined
      * gen by moon at 12/23/2023, 11:07:25 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务改进建议消息内容")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public SubmitReportTaskImpSugMsgRespDto submitReportTaskImpSugMsg(SubmitReportTaskImpSugMsgReqDto reqDto) {
         //SUBMIT_REPORT_TASK_IMP_SUG_MSG
         //{objectName}({targetContentName}{cycleStandardName}汇报)
         SubmitReportTaskImpSugMsgRespDto retData = new SubmitReportTaskImpSugMsgRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("SUBMIT_REPORT_TASK_IMP_SUG_MSG");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String objectName = "\\{objectName}";
             String targetContentName = "\\{targetContentName}";
             String cycleStandardName = "\\{cycleStandardName}";
             if(reqDto!=null&&reqDto.getObjectName()!=null&&reqDto.getTargetContentName()!=null&&reqDto.getCycleStandardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(objectName,reqDto.getObjectName());
                 retConent = retConent.replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:generateSemanticInstance
      * name:M2生成汇报任务工作总结协同内容文案
      * desc:undefined
      * gen by moon at 12/24/2023, 6:14:10 PM
      *
      **/
     @Trace(operationName = "M2生成汇报任务工作总结协同内容文案")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public SubmitReportTaskWorkSummaryTextRespDto submitReportTaskWorkSummaryText(SubmitReportTaskWorkSummaryTextReqDto reqDto) {
         //SUBMIT_REPORT_TASK_WORK_SUMMARY_TEXT
         //{targetContentName}{cycleStandardName}汇报
         SubmitReportTaskWorkSummaryTextRespDto retData = new SubmitReportTaskWorkSummaryTextRespDto();
         Boolean bRetFlag = false;
         String retConent = "";
         QuerySemanticEngineDetailReqDto detailReq = new QuerySemanticEngineDetailReqDto();
         detailReq.setTemplateSemanticEngineCode("SUBMIT_REPORT_TASK_WORK_SUMMARY_TEXT");
         QuerySemanticEngineDetailRespDto detailRes = templateEngineService.querySemanticEngineDetail(detailReq);
         if(detailRes!=null && detailRes.getTemplateEngineTemplate()!=null){
             String targetContentName = "\\{targetContentName}";
             String cycleStandardName = "\\{cycleStandardName}";
             if(reqDto!=null&&reqDto.getTargetContentName()!=null&&reqDto.getCycleStandardName()!=null){
                 bRetFlag = true;
                 retConent = detailRes.getTemplateEngineTemplate().replaceAll(targetContentName,reqDto.getTargetContentName());
                 retConent = retConent.replaceAll(cycleStandardName,reqDto.getCycleStandardName());
                 retData.setObjectName(retConent);
             }

             if(bRetFlag){
                 return retData;
             }

         }
         return retData;
      }
/**
      * code:receptionService
      * name:M2接收字段
      * desc:undefined
      * gen by moon at 12/29/2023, 8:49:42 PM
      *
      **/
     @Trace(operationName = "M2接收字段")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementSmartSessionReceiveFieldInputRespDto implementSmartSessionReceiveFieldInput(ImplementSmartSessionReceiveFieldInputReqDto reqDto) {
         return BeanUtil.toBean(reqDto,ImplementSmartSessionReceiveFieldInputRespDto.class);
      }
/**
      * code:generateSemanticInstance
      * name:M2生成语义实例故事
      * desc:undefined
      * gen by moon at 12/29/2023, 8:50:47 PM
      *
      **/
     @Trace(operationName = "M2生成语义实例故事")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public GenerateSemanticInstanceStoryRespDto generateSemanticInstanceStory(GenerateSemanticInstanceStoryReqDto reqDto) {
         GenerateSemanticInstanceStoryRespDto retData = new GenerateSemanticInstanceStoryRespDto();
         retData.setObjectName(reqDto.getTemplateEngineTemplate());
         for(FieldsNameAndValueToOneDatasDto one : reqDto.getFieldsNameAndValueToOneDatasList()){
             String fileName = "\\{" + one.getFieldName() + "}";
             retData.setObjectName(retData.getObjectName().replaceAll(fileName,one.getFieldValue()));
         }
        return retData;
      }
    //手工接入方法
}
